//////////////////////////////////////////////////////////////////////////////
//																			//
//  Filename:    HillbilliesGuts.cpp										//
//  Developer:   Ben Wardlow												//
//  Create date: 3/01/2006													//
//																			//
//////////////////////////////////////////////////////////////////////////////
//																			//
//  Description: This is the class implementation for the slot gut of the	//
//               Australian Slot machine called Hillbillies.				//
//																			//
//////////////////////////////////////////////////////////////////////////////
//        Copyright (c) 2006 - Realtime Gaming.  All rights reserved.		//
//////////////////////////////////////////////////////////////////////////////

#include "HillbilliesGuts.h"

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aLineWinSpinResults
///
/// This array is used to quickly get the SpinResult for the number of
/// icons.  It is indexed by wheel icon and then count.  So to get the
/// SpinResult for 5 Shacks, use the following code snippet:
///
///		SpinResult result = m_aLineWinSpinResults[ ICON_SHACK ][ 5 ];
///
/// In this example result would be set to EVT_FIVE_SHACK.
////////////////////////////////////////////////////////////////////////////
HillbilliesGuts::SpinResult HillbilliesGuts::m_aLineWinSpinResults[][6] =
{
// Number of icons:			0			1				2					3						4					5
/* ICON_NINE */			{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_THREE_NINE,			EVT_FOUR_NINE,		EVT_FIVE_NINE		},
/* ICON_TEN */			{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_THREE_TEN,			EVT_FOUR_TEN,		EVT_FIVE_TEN		},
/* ICON_JACK */			{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_THREE_JACK,			EVT_FOUR_JACK,		EVT_FIVE_JACK		},
/* ICON_QUEEN */		{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_THREE_QUEEN,		EVT_FOUR_QUEEN,		EVT_FIVE_QUEEN		},
/* ICON_KING */			{	EVT_LOSER,	EVT_LOSER,		EVT_TWO_KING,		EVT_THREE_KING,			EVT_FOUR_KING,		EVT_FIVE_KING		},
/* ICON_ACE */			{	EVT_LOSER,	EVT_LOSER,		EVT_TWO_ACE,		EVT_THREE_ACE,			EVT_FOUR_ACE,		EVT_FIVE_ACE		},
/* ICON_DOG */			{	EVT_LOSER,	EVT_LOSER,		EVT_TWO_DOG,		EVT_THREE_DOG,			EVT_FOUR_DOG,		EVT_FIVE_DOG		},
/* ICON_PIG */			{	EVT_LOSER,	EVT_LOSER,		EVT_TWO_PIG,		EVT_THREE_PIG,			EVT_FOUR_PIG,		EVT_FIVE_PIG		},
/* ICON_MOONSHINE */	{	EVT_LOSER,	EVT_LOSER,		EVT_TWO_MOONSHINE,	EVT_THREE_MOONSHINE,	EVT_FOUR_MOONSHINE,	EVT_FIVE_MOONSHINE	},
/* ICON_SHACK */		{	EVT_LOSER,	EVT_LOSER,		EVT_TWO_SHACK,		EVT_THREE_SHACK,		EVT_FOUR_SHACK,		EVT_FIVE_SHACK		},
/* ICON_BILLY_BOB */	{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_LOSER,				EVT_LOSER,			EVT_LOSER			},
/* ICON_BILLY_BUBBA */	{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_LOSER,				EVT_LOSER,			EVT_LOSER			},
/* ICON_BILLY_JO */		{	EVT_LOSER,	EVT_LOSER,		EVT_LOSER,			EVT_LOSER,				EVT_LOSER,			EVT_LOSER			},
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aHillbillyIcon
///
/// This array is so that we can loop through the reels when looking for which
/// Hillbilly icons are present, instead of having to examine the three possible
/// reels individually.  It is indexed by reel number.
////////////////////////////////////////////////////////////////////////////
uint8 HillbilliesGuts::m_aHillbillyIcon[5] =
{
	ICON_BILLY_BOB,
	ICON_INVALID,
	ICON_BILLY_JO,
	ICON_INVALID,
	ICON_BILLY_BUBBA
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aHillbillyMultiplier
///
/// This array is so that we can loop through the reels when looking for which
/// Hillbilly multipliers to apply, instead of having to examine the three possible
/// reels individually.  It is indexed by reel number.
////////////////////////////////////////////////////////////////////////////
uint8 HillbilliesGuts::m_aHillbillyMultiplier[5] =
{
	MULTIPLIER_HILLBILLY_2X,
	MULTIPLIER_HILLBILLY_NONE,
	MULTIPLIER_HILLBILLY_2X,
	MULTIPLIER_HILLBILLY_NONE,
	MULTIPLIER_HILLBILLY_5X
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aHillbillySubstitutionNote
///
/// This array is so that we can loop through the reels when looking for which
/// Hillbilly Substitution notes to add, instead of having to examine the three
/// possible reels individually.  It is indexed by reel number.
////////////////////////////////////////////////////////////////////////////
int8 HillbilliesGuts::m_aHillbillySubstitutionNote[5] =
{
	NOTE_BILLY_BOB_SUBSTITUTION,
	NOTE_NONE,
	NOTE_BILLY_JO_SUBSTITUTION,
	NOTE_NONE,
	NOTE_BILLY_BUBBA_SUBSTITUTION,
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aHillbillyBonusNote
///
/// This array is so that we can loop through the reels when looking for which
/// Hillbilly Bonus notes to add, instead of having to examine the three
/// possible reels individually.  It is indexed by reel number.
////////////////////////////////////////////////////////////////////////////
int8 HillbilliesGuts::m_aHillbillyBonusNote[5] =
{
	NOTE_BILLY_BOB_BONUS,
	NOTE_NONE,
	NOTE_BILLY_JO_BONUS,
	NOTE_NONE,
	NOTE_BILLY_BUBBA_BONUS,
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aHillbillyScatterMask
///
/// This array is so that we can loop through the reels when examining the
/// scatter positions for possible Hillbillies.  It is indexed by reel number.
////////////////////////////////////////////////////////////////////////////
int32 HillbilliesGuts::m_aHillbillyScatterMask[5] =
{
	SCATTER_REEL_0_MASK,
	0,						// There are no Hillbillies on this reel.
	SCATTER_REEL_2_MASK,
	0,						// There are no Hillbillies on this reel.
	SCATTER_REEL_4_MASK
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aScatterWinSpinResults
///
/// This array is used to quickly get the SpinResult for the number of
/// icons.  It is indexed by icon count only, since Hillbillies are the only
/// scatter win.  So to get the SpinResult for 3 Hillbillies, use the
/// following code snippet:
///
///		SpinResult result = m_aScatterWinSpinResults[ 3 ];
///
/// In this example result would be set to EVT_THREE_HILLBILLY.
////////////////////////////////////////////////////////////////////////////
HillbilliesGuts::SpinResult HillbilliesGuts::m_aScatterWinSpinResults[4] =
{
	// ICON_BILLY_x		   Number of Icons
	EVT_LOSER,				// 0
	EVT_SCATTER_NEAR_MISS,	// 1
	EVT_TWO_HILLBILLY,		// 2
	EVT_THREE_HILLBILLY,	// 3
};

////////////////////////////////////////////////////////////////////////////
/// HillbilliesGuts::m_aFeatureWinSpinResults
///
/// This array is used to quickly get the SpinResult for the number of
/// icons.  It is indexed by icon count only, since Hillbillies are the only
/// scatter win.  So to get the SpinResult for 3 Hillbillies, use the
/// following code snippet:
///
///		SpinResult result = m_aFeatureWinSpinResults[ 3 ];
///
/// In this example result would be set to EVT_FREE_GAME_FEATURE.
////////////////////////////////////////////////////////////////////////////
HillbilliesGuts::SpinResult HillbilliesGuts::m_aFeatureWinSpinResults[4] =
{
	// ICON_BILLY_x		   Number of Icons
	EVT_LOSER,				// 0
	EVT_FEATURE_NEAR_MISS,	// 1
	EVT_FREE_GAME_FEATURE,	// 2
	EVT_FREE_GAME_FEATURE,	// 3
};

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::HillbilliesGuts()
///
/// This is the default constructor for the class.
////////////////////////////////////////////////////////////////////////////
HillbilliesGuts::HillbilliesGuts()
{
	// If this doesn't compile it means that someone probably added
	// another icon type but did not update the
	// m_aLineWinSpinResults array.
	C_ASSERT( countof( m_aLineWinSpinResults ) == NUM_VALID_ICONS );
}

////////////////////////////////////////////////////////////////////////////                                                                  /// @fn 	 HillbilliesGuts::~HillbilliesGuts()
/// @fn 	 HillbilliesGuts::~HillbilliesGuts()
///
/// Destructor for HillbilliesGuts.
////////////////////////////////////////////////////////////////////////////
HillbilliesGuts::~HillbilliesGuts()
{
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::classifyStops()
///
/// @param   stops      The array of stop positions for the line.
/// @param   bet        The value of the line bet.
/// @param   line       The index of the line.
///
/// @return	 uint8      A payout from the SpinResult enumeration as a uint8.
///
/// This helper method is used to calculate the payout on a line.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::classifyStops( SpinLine* spinline, uint8* stops, uint8 bet, uint8 line,
	uint8& rtnresult, uint8& multiplier )
{
	// Declare a local variable to track whether or not we found a substitution.
	bool bSubstitution = false;

	// Also keep track of the number of relevant icons for a line win
	uint8 nNumIcons = 0;

	// See what the payout is if we use any Hillbillies we find as substitution symbols.
	// Start with the icon on the first reel, since all symbols pay left to right.
	uint8 testIcon = getIcon( getGameModeId(), 0, stops[0] )->iconid;

	// See what the spin result is if we used any Hillbillies as substitution symbols.
	SpinResult srResultWithPossibleSubstitution =
		getLineWinResultWithPossibleSubstitution( stops, testIcon, bSubstitution, nNumIcons );

	// Since there is no regular Hillbilly result, just return the result using substitution
	rtnresult = srResultWithPossibleSubstitution;

	// If we did actually have a substitution and a winning spin...
	if ( bSubstitution && srResultWithPossibleSubstitution != EVT_LOSER )
	{
		multiplier = 1;

		// Reuse testIcon to see which Hillbillies are present.
		for ( uint8 i = 0; i < nNumIcons; i++ )
		{
			testIcon = getIcon( getGameModeId(), i, stops[i] )->iconid;

			// If we found a Hillbilly...
			if ( testIcon == m_aHillbillyIcon[ i ] )
			{
				// then add a note and change the multiplier.
				spinline->addNote( m_aHillbillySubstitutionNote[ i ] );
				multiplier *= m_aHillbillyMultiplier[ i ];
			}
		}
	}
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::SpinResult HillbilliesGuts::getLineWinResultWithPossibleSubstitution( uint8* stops, uint8 testIcon, bool& bSubstitution ) const
///
/// @param   stops			The array of stop positions for the line.
/// @param   testIcon		The icon we are looking for, typically the first icon on the line.
/// @param   bSubstitution	An output parameter that is set if a subsitution is used.
///
/// @return	 SpinResult		A payout from the SpinResult enumeration.
///
/// This helper method is used to calculate the line win payout with a possible substitution.
////////////////////////////////////////////////////////////////////////////
HillbilliesGuts::SpinResult HillbilliesGuts::getLineWinResultWithPossibleSubstitution(
	uint8* stops, uint8 testIcon, bool& bSubstitution, uint8& numLineWinIcons ) const
{
	// Initialize the out parameter
	bSubstitution = false;

	// Loop through the remaining reels until the streak is over
	for ( int i = 1; i < getReelCount(); i++ )
    {
		// See what this icon is.
		uint8 currentIcon = getIcon( getGameModeId(), i, stops[i] )->iconid;

		// If the current icon is a Hillbilly...
		if ( isHillbillyIcon( currentIcon ) )
		{
			// then use it as a substitution symbol and continue on.
			bSubstitution = true;
			continue;
		}
		// Otherwise if the test icon is a Hillbilly...
		else if ( isHillbillyIcon( testIcon ) )
		{
			// then we still have a substitution.  In this case the line
			// started out with a Hillbilly.
			bSubstitution = true;

			// We have now found our first icon that is not a Hillbilly.  All
			// of the rest of the icons will have to match this one now for the
			// streak to continue, so change our test icon.
			testIcon = currentIcon;
			continue;
		}

		// If the current icon is not the test icon...
        if ( currentIcon != testIcon )
        {
			// then the streak is over so break out of the loop
			break;
        }
    }

	// Pass this information back to the calling function so we can determine how many
	// Hillbillies, if any, contributed to the line win
	numLineWinIcons = i;

	// Use the array to look up the spin result for i testIcons.
	return lookupLineWinSpinResult( testIcon, i );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::isHillbillyIcon( uint8 testIcon )
///
/// @param   testIcon	The icon to check.
///
/// @return	 bool8      True if icon is a Hillbilly.
///
/// This helper method is used to see if an icon is one of the Hillbilly icons.
////////////////////////////////////////////////////////////////////////////
bool8 HillbilliesGuts::isHillbillyIcon( uint8 testIcon ) const
{
	return testIcon == ICON_BILLY_BOB || testIcon == ICON_BILLY_JO || testIcon == ICON_BILLY_BUBBA;
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::classifyScatters( SlotSpin* spin )
///
/// @param   spin       Pointer to the spin with stop data.
///
/// This is an override of the framework method.
/// It determines if the current spin merits free spins or scatter payments.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::classifyScatters( SlotSpin* spin )
{
	// Try for the Random Progressive Jackpot
	tryForJackpot( spin );

	// Declare a local variable to track the scatter positions.
	int32 nScatterPositions = 0;

	// See if there is a scatter.
	uint8 numHillbillyIcons = getNumHillbillyIcons( spin, nScatterPositions );
	SpinResult srResult = lookupScatterWinSpinResult( numHillbillyIcons );

	// Add the scatter, if any.
	evaluateScatterWin( spin, srResult, nScatterPositions );
		
	// See if there is a HillbillyBonus
	if ( srResult != EVT_LOSER )
	{
		// Since one Hillbilly is necessary to trigger Hillbilly Bonus.
		evaluateHillbillyBonusWin( spin, EVT_HILLBILLY_BONUS, nScatterPositions );
	}

	// See if we triggered the free game feature.
	srResult = lookupFeatureWinSpinResult( numHillbillyIcons );
	evaluateFeatureTrigger( spin, srResult, nScatterPositions );
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::getNumHillbillyIcons()
///
/// @param   spin				The current spin object.
/// @param   scatterPositions	The bit mask for the scatter positions that we find.
///
/// @return	 SpinResult			A payout from the SpinResult enumeration.
///
/// This helper method is used to evaluate the spin for scatters.
////////////////////////////////////////////////////////////////////////////
uint8  HillbilliesGuts::getNumHillbillyIcons( SlotSpin* spin, int32& scatterPositions ) const
{
	// Declare a local variable to keep up with the icon count.
	uint8 numHillbillyIcons = 0;

	// Initialize the scatterPositions.
	scatterPositions = 0;

	// Loop through each reel.
  	for( int reel = 0; reel < getReelCount(); reel++ )
	{
		// The position bit for the current icon in case it needs to be stored in a mask.
		uint8 position = reel;

		// Keep up with whether or not we find an icon on this reel
		bool bFoundScatterIconOnReel = false;

		// Loop through each row in the wheel house.
		for( int row = 0; row < 3; row++ )
		{
			// Get the current stop.
			uint8 stop = relativeWheelPosition( getGameModeId(), reel,
				spin->getStops()[ reel ], row );

			// Get the icon for the current stop.
			uint8 currentIcon = getIcon( getGameModeId(), reel, stop )->iconid;

			// If the icon is one we are looking for...
			if ( isHillbillyIcon(currentIcon) )
			{
				// then increase the icon count
				numHillbillyIcons++;

				// Set the bit in the position mask for this stop.
				scatterPositions |= 1 << position;

				// We found a scatter icon.
				bFoundScatterIconOnReel = true;
			}

			// Move to the next bit in the position mask.
            position += 5;
		}
	}

	return numHillbillyIcons;
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::evaluateScatterWin()
///
/// This function determines if the current spin wins a scatter payment and
/// adds the scatter.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::evaluateScatterWin( SlotSpin* spin, SpinResult srScatterResult, int32 scatterPositions )
{
	// If we got the scatter win (or almost got it)
	if ( srScatterResult != EVT_LOSER )
	{
		// Initialize the multiplier.
		int32 multiplier = 1;

		// If we are in free spin mode...
		if ( getGameModeId() == MODE_FREE_SPIN )
		{
			// then use the free spin multiplier.
			multiplier = MULTIPLIER_FREE_SPIN;
		}

		// Get the base payout for the scatter.
		int32 nPayout = getPayout( srScatterResult )->payoutAmount;

		// Scatters payout based on the total bet, so factor in the number of bet lines.
		nPayout *= spin->getSpinLineCount();

		// Add the payout (with multiplier) to the total win for this spin.
		increaseTotalWin( nPayout * multiplier );

		// Add a scatter to the spin.
		SlotScatter* pScatter = spin->addScatter( scatterPositions,
			nPayout * getBetPerLine(), multiplier, false, srScatterResult, 0 );

		// If the free spin multiplier was used...
		if ( multiplier == MULTIPLIER_FREE_SPIN )
		{
			// then add the free spin note.
			pScatter->addNote( NOTE_FREE_SPIN );
		}
	}
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::evaluateHillbillyBonusWin()
///
/// This function determines if the current spin wins a Hillbilly Bonus and
/// adds the scatter.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::evaluateHillbillyBonusWin( SlotSpin* spin, SpinResult srScatterResult, int32 scatterPositions )
{
	// If we got the Hillbilly Bonus win (which happens only on free games)...
	if ( ( getGameModeId() == MODE_FREE_SPIN ) && ( srScatterResult != EVT_LOSER ) )
	{
		// Initialize the multiplier (which is a sum of Hillbilly multipliers, not
		// a product of multipliers, so start with zero).
		int32 multiplier = 0;

		// Get the base payout for the Hillbilly Bonus.
		int32 nPayout = getPayout( srScatterResult )->payoutAmount;

		// Hillbilly Bonus payout based on the total bet, so factor in the number of bet lines.
		nPayout *= spin->getSpinLineCount();

		// Determine our multiplier (need to do this before adding scatter to spin).
	  	for( int reel = 0; reel < getReelCount(); reel++ )
	  	{
	  		if ( scatterPositions & m_aHillbillyScatterMask[ reel ] )
	  		{
	  			multiplier += m_aHillbillyMultiplier[ reel ];
	  		}
	  	}

		// Add the payout (with multiplier) to the total win for this spin.
		increaseTotalWin( nPayout * multiplier );

		// Add a scatter to the spin.
		SlotScatter* pScatter = spin->addScatter( scatterPositions,
			nPayout * getBetPerLine(), multiplier, false, EVT_HILLBILLY_BONUS, 0 );

		// Now that the scatter is created, add the appropriate notes.
	  	for( reel = 0; reel < getReelCount(); reel++ )
	  	{
	  		if ( scatterPositions & m_aHillbillyScatterMask[ reel ] )
	  		{
	  			pScatter->addNote( m_aHillbillyBonusNote[ reel ]);
	  		}
	  	}
	}
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::evaluateFeatureTrigger()
///
/// This function determines if the current spin triggers the free game
///	feature and adds the scatter.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::evaluateFeatureTrigger( SlotSpin* spin, SpinResult srFeatureTriggerResult, int32 featurePositions )
{
	// We need a place to keep up with how many free spins to award.
	int32 nFreeSpins = 0;

	// Figure out how many free spins they get.
	if ( srFeatureTriggerResult == EVT_FREE_GAME_FEATURE )
	{
		// If we are not already in free spin mode...
		if ( getGameModeId() != MODE_FREE_SPIN )
		{
			// Change the game mode.
			setGameModeId( MODE_FREE_SPIN );
		}

		// Add the free spins.
		nFreeSpins = 8;
		incrementFreeSpins( nFreeSpins );
	}
	else if ( srFeatureTriggerResult == EVT_LOSER )
	{
		return;
	}

	// Add a scatter to the spin for the feature trigger.
	spin->addScatter( featurePositions, 0, 0, false,
		srFeatureTriggerResult, nFreeSpins );
}

////////////////////////////////////////////////////////////////////////////
/// @fn		HillbilliesGuts::tryForJackpot()
///
///	This function tries to win the jackpot and adds the scatter if we hit
/// the jackpot.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::tryForJackpot( SlotSpin* spin )
{
	// If we are in the first paid spin (NOT a bonus spin)...
	if ( getGameModeId() == MODE_NORMAL )
	{
		// then try for the Random Progressive Jackpot
		// If we hit the jackpot...
		if ( getRandomProgressiveJackpotResult( spin->getSpinLineCount() ) ||
             m_bForceRandomJackpot == true)
		{
			// then add a jackpot scatter to the spin.
			spin->addScatter( 0,
				getPayout( EVT_RANDOM_PROGRESSIVE_WINNER )->payoutAmount, 1,
				true, EVT_RANDOM_PROGRESSIVE_WINNER, 0 );
		}
    }
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::isValidGuts()
///
/// @return	 bool8      True if gut is valid.
///
/// This helper method is used to see if the current gut ID is valid.
////////////////////////////////////////////////////////////////////////////
bool8 HillbilliesGuts::isValidGuts()
{
	return getGutsId() >= MIN && getGutsId() < MAX ;
}

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::getGameModeMultiplierAndNoteId( uint8& nGameModeMultiplier, uint8& nNoteId )
///
/// @param   nGameModeMultiplier	The multiplier for the game mode.
/// @param   nNoteId				The note ID for the game mode.
///
/// This helper method is used to get the game mode multiplier and note ID.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::getGameModeMultiplierAndNoteId( uint8& nGameModeMultiplier,
	uint8& nNoteId )
{
	// If we are in free spin mode...
    if ( getGameModeId() == MODE_FREE_SPIN )
    {
		// then return the free spin multiplier...
        nGameModeMultiplier = MULTIPLIER_FREE_SPIN;

		// and the free spin note.
        nNoteId = NOTE_FREE_SPIN;
    }
	// Otherwise...
    else
    {
		// just defer to the base class.
        SlotGuts::getGameModeMultiplierAndNoteId( nGameModeMultiplier, nNoteId );
    }
}


////////////////////////////////////////////////////////////////////////////////////////////////////
//
//	Debugging code
//
////////////////////////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////
/// @fn 	 HillbilliesGuts::preSpinClassifyResults( SlotSpin* spin )
///
/// @param   spin       Pointer to the spin with stop data.
///
/// This method is overridden in debug spins mode to alter the reel stops.
////////////////////////////////////////////////////////////////////////////
void HillbilliesGuts::preSpinClassifyResults( SlotSpin* spin )
{
	SlotGuts::preSpinClassifyResults(spin);
	return;
}